home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / language / embedded / ibm / r3sim.arc / INSTR.C next >
C/C++ Source or Header  |  1989-07-08  |  20KB  |  661 lines
  1. /********
  2.     program: 68705R3 simulator
  3.     file: instr.c - instruction table, instruction and interrupt
  4.         simulation.  See instr2.c for individual instruction
  5.         routines.
  6.     Author: Joseph Schachner
  7.     Notes: 
  8. ********/
  9.  
  10. #include <stdio.h>
  11. #include "sim.h"
  12.  
  13. #ifdef MSC
  14. #include <dos.h>
  15. #endif
  16.  
  17. extern FILE *logfile;
  18.  
  19. struct instruction_table_entry {
  20.     PFI function;
  21.     int argument;
  22.     char *name;
  23.     int ncycles;
  24. };
  25.  
  26. /* The following three items are filled by routines in here and instr2
  27.    and are printed out nicely formatted from sim_instr, below 
  28. */
  29. char mne[40];
  30. char opcode[40];
  31. char rw[40];
  32.  
  33. /* Part of this string is used to fill between fields, as needed */
  34. char blanks[]="                                        ";  /* 40 blanks */
  35.  
  36. char inval_str[]="Invalid op";
  37.  
  38. invalid( mode)
  39. int mode;
  40. {
  41.     sim_halt();
  42. }
  43.  
  44. extern int brset(),brclr(),bset(),bclr(),branch();
  45. extern int neg(),com(),lsr(),ror(),asr(),lsl(),rol(),dec(),inc(),tst(),clr();
  46. extern int rti(),rts(),swi(),tax(),clc(),sec(),cli(),sei(),rsp(),nop(),txa();
  47. extern int sub(),cmp(),sbc(),cpx(),and(),bit(),lda(),sta(),eor(),adc(),ora();
  48. extern int add(),jmp(),bsr(),jsr(),ldx(),stx();
  49.  
  50.  
  51. struct instruction_table_entry instr_tbl[] =
  52. {
  53.     { brset, 0, "BRSET0", 10 },
  54.     { brclr, 0, "BRCLR0", 10 },
  55.     { brset, 1, "BRSET1", 10 },
  56.     { brclr, 1, "BRCLR1", 10 },
  57.     { brset, 2, "BRSET2", 10 },
  58.     { brclr, 2, "BRCLR2", 10 },
  59.     { brset, 3, "BRSET3", 10 },
  60.     { brclr, 3, "BRCLR3", 10 },
  61.     { brset, 4, "BRSET4", 10 },
  62.     { brclr, 4, "BRCLR4", 10 },
  63.     { brset, 5, "BRSET5", 10 },
  64.     { brclr, 5, "BRCLR5", 10 },
  65.     { brset, 6, "BRSET6", 10 },
  66.     { brclr, 6, "BRCLR6", 10 },
  67.     { brset, 7, "BRSET7", 10 },
  68.     { brclr, 7, "BRCLR7", 10 },
  69.     { bset, 0, "BSET0", 7 },
  70.     { bclr, 0, "BCLR0", 7 },
  71.     { bset, 1, "BSET1", 7 },
  72.     { bclr, 1, "BCLR1", 7 },
  73.     { bset, 2, "BSET2", 7 },
  74.     { bclr, 2, "BCLR2", 7 },
  75.     { bset, 3, "BSET3", 7 },
  76.     { bclr, 3, "BCLR3", 7 },
  77.     { bset, 4, "BSET4", 7 },
  78.     { bclr, 4, "BCLR4", 7 },
  79.     { bset, 5, "BSET5", 7 },
  80.     { bclr, 5, "BCLR5", 7 },
  81.     { bset, 6, "BSET6", 7 },
  82.     { bclr, 6, "BCLR6", 7 },
  83.     { bset, 7, "BSET7", 7 },
  84.     { bclr, 7, "BCLR7", 7 },
  85.     { branch, 0, "BRA", 4 },
  86.     { branch, 1, "BRN", 4 },
  87.     { branch, 2, "BHI", 4 },
  88.     { branch, 3, "BLS", 4 },
  89.     { branch, 4, "BCC", 4 },
  90.     { branch, 5, "BCS", 4 },
  91.     { branch, 6, "BNE", 4 },
  92.     { branch, 7, "BEQ", 4 },
  93.     { branch, 8, "BHCC",4 },
  94.     { branch, 9, "BHCS",4 },
  95.     { branch, 10, "BPL", 4 },
  96.     { branch, 11, "BMI", 4 },
  97.     { branch, 12, "BMC", 4 },
  98.     { branch, 13, "BMS", 4 },
  99.     { branch, 14, "BIL", 4 },
  100.     { branch, 15, "BIH", 4 },
  101.     { neg,  DIRECT, "NEG", 6 },
  102.     { invalid,  DIRECT, inval_str, 0 },
  103.     { invalid,  DIRECT, inval_str, 0 },
  104.     { com,  DIRECT, "COM", 6 },
  105.     { lsr,  DIRECT, "LSR", 6 },
  106.     { invalid,  DIRECT, inval_str, 0 },
  107.     { ror,  DIRECT, "ROR", 6 },
  108.     { asr,  DIRECT, "ASR", 6 },
  109.     { lsl,  DIRECT, "LSL", 6 },
  110.     { rol,  DIRECT, "ROL", 6 },
  111.     { dec,  DIRECT, "DEC", 6 },
  112.     { invalid,  DIRECT, inval_str, 0 },
  113.     { inc,  DIRECT, "INC", 6 },
  114.     { tst,  DIRECT, "TST", 6 },
  115.     { invalid,  DIRECT, inval_str, 0 },
  116.     { clr,  DIRECT, "CLR", 6 },
  117.     { neg,  ACCUM, "NEGA", 4 },
  118.     { invalid,  ACCUM, inval_str, 0 },
  119.     { invalid,  ACCUM, inval_str, 0 },
  120.     { com,  ACCUM, "COMA", 4 },
  121.     { lsr,  ACCUM, "LSRA", 4 },
  122.     { invalid,  ACCUM, inval_str, 0 },
  123.     { ror,  ACCUM, "RORA", 4 },
  124.     { asr,  ACCUM, "ASRA", 4 },
  125.     { lsl,  ACCUM, "LSLA", 4 },
  126.     { rol,  ACCUM, "ROLA", 4 },
  127.     { dec,  ACCUM, "DECA", 4 },
  128.     { invalid,  ACCUM, inval_str, 0 },
  129.     { inc,  ACCUM, "INCA", 4 },
  130.     { tst,  ACCUM, "TSTA", 4 },
  131.     { invalid,  ACCUM, inval_str, 0 },
  132.     { clr,  ACCUM, "CLRA", 4 },
  133.     { neg,  XREG, "NEGX", 4 },
  134.     { invalid,  XREG, inval_str, 0 },
  135.     { invalid,  XREG, inval_str, 0 },
  136.     { com,  XREG, "COMX", 4 },
  137.     { lsr,  XREG, "LSRX", 4 },
  138.     { invalid,  XREG, inval_str, 0 },
  139.     { ror,  XREG, "RORX", 4 },
  140.     { asr,  XREG, "ASRX", 4 },
  141.     { lsl,  XREG, "LSLX", 4 },
  142.     { rol,  XREG, "ROLX", 4 },
  143.     { dec,  XREG, "DECX", 4 },
  144.     { invalid,  XREG, inval_str, 0 },
  145.     { inc,  XREG, "INCX", 4 },
  146.     { tst,  XREG, "TSTX", 4 },
  147.     { invalid,  XREG, inval_str, 0 },
  148.     { clr,  XREG, "CLRX", 4 },
  149.     { neg,  AT_X_BYTE_OFFSET, "NEG", 7 },
  150.     { invalid,  AT_X_BYTE_OFFSET, inval_str, 0 },
  151.     { invalid,  AT_X_BYTE_OFFSET, inval_str, 0 },
  152.     { com,  AT_X_BYTE_OFFSET, "COM", 7 },
  153.     { lsr,  AT_X_BYTE_OFFSET, "LSR", 7 },
  154.     { invalid,  AT_X_BYTE_OFFSET, inval_str, 0 },
  155.     { ror,  AT_X_BYTE_OFFSET, "ROR", 7 },
  156.     { asr,  AT_X_BYTE_OFFSET, "ASR", 7 },
  157.     { lsl,  AT_X_BYTE_OFFSET, "LSL", 7 },
  158.     { rol,  AT_X_BYTE_OFFSET, "ROL", 7 },
  159.     { dec,  AT_X_BYTE_OFFSET, "DEC", 7 },
  160.     { invalid,  AT_X_BYTE_OFFSET, inval_str, 0 },
  161.     { inc,  AT_X_BYTE_OFFSET, "INC", 7 },
  162.     { tst,  AT_X_BYTE_OFFSET, "TST", 7 },
  163.     { invalid,  AT_X_BYTE_OFFSET, inval_str, 0 },
  164.     { clr,  AT_X_BYTE_OFFSET, "CLR", 7},
  165.     { neg,  AT_X, "NEG ,X", 6 },
  166.     { invalid,  AT_X, inval_str, 0 },
  167.     { invalid,  AT_X, inval_str, 0 },
  168.     { com,  AT_X, "COM ,X", 6 },
  169.     { lsr,  AT_X, "LSR ,X", 6 },
  170.     { invalid,  AT_X, inval_str, 0 },
  171.     { ror,  AT_X, "ROR ,X", 6 },
  172.     { asr,  AT_X, "ASR ,X", 6 },
  173.     { lsl,  AT_X, "LSL ,X", 6 },
  174.     { rol,  AT_X, "ROL ,X", 6 },
  175.     { dec,  AT_X, "DEC ,X", 6 },
  176.     { invalid,  AT_X, inval_str, 0 },
  177.     { inc,  AT_X, "INC ,X", 6 },
  178.     { tst,  AT_X, "TST ,X", 6 },
  179.     { invalid,  AT_X, inval_str, 0 },
  180.     { clr,  AT_X, "CLR ,X", 6 },
  181.     { rti,  INH, "RTI", 9 },
  182.     { rts,  INH, "RTS", 6 },
  183.     { invalid,  INH, inval_str, 0 },
  184.     { swi,  INH, "SWI", 11 },
  185.     { invalid,  INH, inval_str, 0 },
  186.     { invalid,  INH, inval_str, 0 },
  187.     { invalid,  INH, inval_str, 0 },
  188.     { invalid,  INH, inval_str, 0 },
  189.     { invalid,  INH, inval_str, 0 },
  190.     { invalid,  INH, inval_str, 0 },
  191.     { invalid,  INH, inval_str, 0 },
  192.     { invalid,  INH, inval_str, 0 },
  193.     { invalid,  INH, inval_str, 0 },
  194.     { invalid,  INH, inval_str, 0 },
  195.     { invalid,  INH, inval_str, 0 },
  196.     { invalid,  INH, inval_str, 0 },
  197.     { invalid,  INH, inval_str, 0 },
  198.     { invalid,  INH, inval_str, 0 },
  199.     { invalid,  INH, inval_str, 0 },
  200.     { invalid,  INH, inval_str, 0 },
  201.     { invalid,  INH, inval_str, 0 },
  202.     { invalid,  INH, inval_str, 0 },
  203.     { invalid,  INH, inval_str, 0 },
  204.     { tax, INH, "TAX", 2 },
  205.     { clc, INH, "CLC", 2 },
  206.     { sec, INH, "SEC", 2 },
  207.     { cli, INH, "CLI", 2 },
  208.     { sei, INH, "SEI", 2 },
  209.     { rsp, INH, "RSP", 2 },
  210.     { nop, INH, "NOP", 2 },
  211.     { invalid,  INH, inval_str, 0 },
  212.     { txa, INH, "TXA", 2 },
  213.     { sub, IMM, "SUB", 2 },
  214.     { cmp, IMM, "CMP", 2 },
  215.     { sbc, IMM, "SBC", 2 },
  216.     { cpx, IMM, "CPX", 2 },
  217.     { and, IMM, "AND", 2 },
  218.     { bit, IMM, "BIT", 2 },
  219.     { lda, IMM, "LDA", 2 },
  220.     { invalid,  IMM, inval_str, 0 },
  221.     { eor, IMM, "EOR", 2 },
  222.     { adc, IMM, "ADC", 2 },
  223.     { ora, IMM, "ORA", 2 },
  224.     { add, IMM, "ADD", 2 },
  225.     { invalid,  IMM, inval_str, 0 },
  226.     { bsr, REL, "BSR", 8 },
  227.     { ldx, IMM, "LDX", 2 },
  228.     { invalid,  IMM, inval_str, 0 },
  229.     { sub, DIRECT, "SUB", 4 },
  230.     { cmp, DIRECT, "CMP", 4 },
  231.     { sbc, DIRECT, "SBC", 4 },
  232.     { cpx, DIRECT, "CPX", 4 },
  233.     { and, DIRECT, "AND", 4 },
  234.     { bit, DIRECT, "BIT", 4 },
  235.     { lda, DIRECT, "LDA", 4 },
  236.     { sta, DIRECT, "STA", 5 },
  237.     { eor, DIRECT, "EOR", 4 },
  238.     { adc, DIRECT, "ADC", 4 },
  239.     { ora, DIRECT, "ORA", 4 },
  240.     { add, DIRECT, "ADD", 4 },
  241.     { jmp, DIRECT, "JMP", 3 },
  242.     { jsr, DIRECT, "JSR", 7 },
  243.     { ldx, DIRECT, "LDX", 4 },
  244.     { stx, DIRECT, "STX", 5 },
  245.     { sub, EXT, "SUB", 5 },
  246.     { cmp, EXT, "CMP", 5 },
  247.     { sbc, EXT, "SBC", 5 },
  248.     { cpx, EXT, "CPX", 5 },
  249.     { and, EXT, "AND", 5 },
  250.     { bit, EXT, "BIT", 5 },
  251.     { lda, EXT, "LDA", 5 },
  252.     { sta, EXT, "STA", 6 },
  253.     { eor, EXT, "EOR", 5 },
  254.     { adc, EXT, "ADC", 5 },
  255.     { ora, EXT, "ORA", 5 },
  256.     { add, EXT, "ADD", 5 },
  257.     { jmp, EXT, "JMP", 4 },
  258.     { jsr, EXT, "JSR", 6 },
  259.     { ldx, EXT, "LDX", 5 },
  260.     { stx, EXT, "STX", 6 },
  261.     { sub, AT_X_WORD_OFFSET, "SUB", 6 },
  262.     { cmp, AT_X_WORD_OFFSET, "CMP", 6 },
  263.     { sbc, AT_X_WORD_OFFSET, "SBC", 6 },
  264.     { cpx, AT_X_WORD_OFFSET, "CPX", 6 },
  265.     { and, AT_X_WORD_OFFSET, "AND", 6 },
  266.     { bit, AT_X_WORD_OFFSET, "BIT", 6 },
  267.     { lda, AT_X_WORD_OFFSET, "LDA", 6 },
  268.     { sta, AT_X_WORD_OFFSET, "STA", 7 },
  269.     { eor, AT_X_WORD_OFFSET, "EOR", 6 },
  270.     { adc, AT_X_WORD_OFFSET, "ADC", 6 },
  271.     { ora, AT_X_WORD_OFFSET, "ORA", 6 },
  272.     { add, AT_X_WORD_OFFSET, "ADD", 6 },
  273.     { jmp, AT_X_WORD_OFFSET, "JMP", 5 },
  274.     { jsr, AT_X_WORD_OFFSET, "JSR", 9 },
  275.     { ldx, AT_X_WORD_OFFSET, "LDX", 6 },
  276.     { stx, AT_X_WORD_OFFSET, "STX", 7 },
  277.     { sub, AT_X_BYTE_OFFSET, "SUB", 5 },
  278.     { cmp, AT_X_BYTE_OFFSET, "CMP", 5 },
  279.     { sbc, AT_X_BYTE_OFFSET, "SBC", 5 },
  280.     { cpx, AT_X_BYTE_OFFSET, "CPX", 5 },
  281.     { and, AT_X_BYTE_OFFSET, "AND", 5 },
  282.     { bit, AT_X_BYTE_OFFSET, "BIT", 5 },
  283.     { lda, AT_X_BYTE_OFFSET, "LDA", 5 },
  284.     { sta, AT_X_BYTE_OFFSET, "STA", 6 },
  285.     { eor, AT_X_BYTE_OFFSET, "EOR", 5 },
  286.     { adc, AT_X_BYTE_OFFSET, "ADC", 5 },
  287.     { ora, AT_X_BYTE_OFFSET, "ORA", 5 },
  288.     { add, AT_X_BYTE_OFFSET, "ADD", 5 },
  289.     { jmp, AT_X_BYTE_OFFSET, "JMP", 4 },
  290.     { jsr, AT_X_BYTE_OFFSET, "JSR", 8 },
  291.     { ldx, AT_X_BYTE_OFFSET, "LDX", 5 },
  292.     { stx, AT_X_BYTE_OFFSET, "STX", 6 },
  293.     { sub, AT_X, "SUB ,X", 4 },
  294.     { cmp, AT_X, "CMP ,X", 4 },
  295.     { sbc, AT_X, "SBX ,X", 4 },
  296.     { cpx, AT_X, "CPX ,X", 4 },
  297.     { and, AT_X, "AND ,X", 4 },
  298.     { bit, AT_X, "BIT ,X", 4 },
  299.     { lda, AT_X, "LDA ,X", 4 },
  300.     { sta, AT_X, "STA ,X", 5 },
  301.     { eor, AT_X, "EOR ,X", 4 },
  302.     { adc, AT_X, "ADC ,X", 4 },
  303.     { ora, AT_X, "ORA ,X", 4 },
  304.     { add, AT_X, "ADD ,X", 4 },
  305.     { jmp, AT_X, "JMP ,X", 3 },
  306.     { jsr, AT_X, "JSR ,X", 7 },
  307.     { ldx, AT_X, "LDX ,X", 4 },
  308.     { stx, AT_X, "STX ,X", 5 }
  309. };
  310.  
  311. struct program_model pgm_model;
  312.  
  313. /**********************************************************************/
  314. int sim_reset()
  315. {
  316.     /* See figure 7-7 in 6805 tech data for reset, intr handling desc */
  317.  
  318.     pgm_model.ccr = CC_I;
  319.     rsp( INH);          /* reset stack pointer to $7F */
  320.     sim_write( PORT_A_DDR, 0 );
  321.     sim_write( PORT_B_DDR, 0 );
  322.     sim_write( PORT_C_DDR,0  );
  323.     external_intr = 0;   /* clear INT request latch */
  324.     sim_write( TIMER_CONTROL, 0x7F);
  325.     sim_write( MISC_REGISTER, 0xFF);
  326.     sim_timer_init();   /* prescaler and ctr to all 1, set TCR bit */
  327.                         /* see 5-8 , 6805 tech data, for more. */
  328.     
  329.     /* Load options from MOR into control logic */
  330.     /* partially done by sim_timer_init, above */
  331.  
  332.     pgm_model.pc = (sim_read( 0xFFE) << 8) + sim_read( 0xFFF);    
  333.     cycle_count = 0;
  334. }
  335. /**********************************************************************/
  336. int get_ea( addr_mode )
  337. /* Called by most routines in instr2.c.  Returns the address from which
  338.    data is to be fetched (or to which to write), based on address mode
  339.    and an appropriate number of bytes at the current pc, which is assumed
  340.    to point to the byte after the instruction.
  341.    (Exception: bit-test-and-branch instructions call this routine twice:
  342.    the first time mode is DIRECT to get the address of the byte to test,
  343.    and the second time mode is BTB to get the address to which to branch.)
  344. */
  345. {
  346.     int retval, i, j;
  347.     char buff[40];
  348.  
  349.     switch (addr_mode)
  350.     {
  351.     case ACCUM:
  352.     retval = RW_A;
  353.     break;
  354.     case XREG:
  355.     retval = RW_X;
  356.     break;
  357.     case AT_X:
  358.     retval = pgm_model.x;
  359.     break;
  360.     case AT_X_BYTE_OFFSET:
  361.     retval = sim_read( pgm_model.pc);
  362.     if (display_enabled)
  363.     {
  364.             sprintf( buff, "   $%x,X", retval);
  365.             strcat( mne, buff);
  366.         sprintf( buff, " %02x", retval);
  367.         strcat( opcode, buff);
  368.         }
  369.     retval += pgm_model.x;
  370.     pgm_model.pc++;
  371.     break;
  372.     case AT_X_WORD_OFFSET:
  373.     i = sim_read( pgm_model.pc);
  374.     pgm_model.pc++;
  375.     j = sim_read( pgm_model.pc);
  376.     pgm_model.pc++;
  377.         retval = i * 256 + j;
  378.         if (display_enabled)
  379.         {
  380.             sprintf( buff, "   $%x,X", retval);
  381.             strcat( mne, buff);
  382.         sprintf( buff, " %02x %02x", i, j);
  383.         strcat( opcode, buff);
  384.         }
  385.     retval += pgm_model.x;
  386.     break;
  387.     case IMM:
  388.     i = sim_read( pgm_model.pc);
  389.     retval = pgm_model.pc;
  390.     pgm_model.pc++;
  391.         if (display_enabled)
  392.         {
  393.         sprintf( buff, "   #$%02x", i);
  394.             strcat( mne, buff);
  395.         sprintf( buff, " %02x", i);
  396.         strcat( opcode, buff);
  397.      }
  398.     break;    
  399.     case DIRECT:
  400.     retval = sim_read( pgm_model.pc);
  401.     pgm_model.pc++;
  402.     if (display_enabled)
  403.     {
  404.         sprintf( buff, "   $%02x", retval);
  405.             strcat( mne, buff);
  406.         sprintf( buff, " %02x", retval);
  407.         strcat( opcode, buff );
  408.     }
  409.     break;
  410.     case EXT:
  411.     i = sim_read( pgm_model.pc);
  412.     pgm_model.pc++;
  413.     j = sim_read( pgm_model.pc);
  414.     pgm_model.pc++;
  415.         retval = i * 256 + j;
  416.         if (display_enabled)
  417.         {
  418.             sprintf( buff, "   $%03x", retval);
  419.             strcat( mne, buff);
  420.         sprintf( buff, " %02x %02x", i, j);
  421.         strcat( opcode, buff);
  422.         }
  423.     break;
  424.     case BTB: /* second of two bytes for BTB - first is DIRECT, second REL */
  425.     j = i = sim_read( pgm_model.pc);
  426.     pgm_model.pc++;
  427.     if (i > 127)
  428.         i -= 256;
  429.     retval = pgm_model.pc + i;
  430.     if (display_enabled)
  431.     {
  432.         sprintf( buff, ",$%03x", retval);
  433.             strcat( mne, buff);
  434.         sprintf( buff, " %02x", j);
  435.         strcat( opcode, buff );  /* skip 2 of 3 leading spaces */
  436.     }
  437.     break;
  438.     case REL:
  439.     j = i = sim_read( pgm_model.pc);
  440.     pgm_model.pc++;
  441.     if (i > 127)
  442.         i -= 256;
  443.     retval = pgm_model.pc + i;
  444.     if (display_enabled)
  445.     {
  446.         sprintf( buff, "   $%03x", retval);
  447.             strcat( mne, buff);
  448.         sprintf( buff, " %02x", j);
  449.         strcat( opcode, buff );  /* skip 2 of 3 leading spaces */
  450.     }
  451.     break;
  452.     default:
  453.         retval = -1;
  454.     }
  455.     return( retval);
  456. }
  457. /**********************************************************************/
  458. int sim_instr()
  459. /* Called from instr_or_intr, below, to do instruction at pc */
  460. /* Also called from sim_r3.c for disassembly */
  461. {
  462.     int iopcode, i, j;
  463.  
  464.     iopcode = sim_read( pgm_model.pc );
  465.     sprintf( opcode, "%03x  %02x", pgm_model.pc, iopcode);
  466.     pgm_model.pc++;
  467.     strcpy( mne, instr_tbl[iopcode].name);
  468.     rw[0] = '\0';    /* empty string */
  469.     if (!disassemble)
  470.     sim_timer_update( instr_tbl[iopcode].ncycles );    
  471.  
  472.     (*instr_tbl[iopcode].function)( instr_tbl[iopcode].argument);
  473.  
  474.     if (!disassemble)
  475.     cycle_count += instr_tbl[iopcode].ncycles;
  476.     if (display_enabled)
  477.     {
  478.     settextposition( 7, 1);
  479.     delete_line(PROMPTLINE+2);
  480.     settextposition( 24, 1);
  481.     printf( "%s", opcode );
  482.     settextposition( 24, 19);
  483.     printf( "%s", mne);
  484.     if (!disassemble)
  485.     {
  486.         settextposition( 24, 40);
  487.         printf( "%s", rw); /* nothing in rw if disassemble, see append_rw*/
  488.         settextposition( 24, 70);
  489.         printf( "%9ld", cycle_count);
  490.     }
  491.     settextposition( PROMPTLINE, 1);  /* return cursor to default pos */
  492.     
  493.     if (log_enabled)       /* Note: never true if disassemble */
  494.     {
  495.         fprintf( logfile, "%s", opcode);
  496.             i = strlen( opcode);
  497.         fprintf( logfile, "%s", &blanks[40-19+i]);
  498.         fprintf( logfile, "%s", mne );
  499.         i = strlen( mne);
  500.         fprintf( logfile, "%s", &blanks[40-(40-19)+i]);
  501.         fprintf( logfile, "%s", rw);
  502.         i = strlen( rw);
  503.         fprintf( logfile, "%s", &blanks[40-(70-40)+i]);
  504.         fprintf( logfile, "%9ld\n", cycle_count);
  505.     }
  506.     }
  507. }
  508. /**********************************************************************/
  509. int pull()
  510. /* The 6805 has no user "pull" instruction.  That's why this routine is
  511.    here, instead of in instr2.c.  This routine used by rts, rti in instr2
  512. */
  513. {
  514.     if (pgm_model.sp < 0x7F)
  515.     pgm_model.sp++;
  516.     else
  517.     pgm_model.sp = 0x61;
  518.     return( sim_read( pgm_model.sp));
  519. }
  520. /**********************************************************************/
  521. int push( value)
  522. int value;
  523. /* The 6805 series has no user "push" instruction.  That's why this routine
  524.    is here, instead of in instr2.c.  This routine used by 'interrupt', below
  525. */
  526. {
  527.     sim_write( pgm_model.sp, value);
  528.     if (pgm_model.sp > 0x61)
  529.     pgm_model.sp--;
  530.     else
  531.     pgm_model.sp = 0x7F; 
  532. }
  533. /**********************************************************************/
  534. int rinterrupt( vector_addr)
  535. /* Stack registers, fetch vector, and display a message */
  536. {
  537.     push( pgm_model.pc & 0xFF);                /* PCL */
  538.     push( ((pgm_model.pc & 0xF00) >> 8) | 0xF0 );    /* PCH */
  539.     push( pgm_model.x);                    /*  X  */
  540.     push( pgm_model.a);                    /*  A  */
  541.     push( pgm_model.ccr | 0xE0 );            /* CCR */
  542.     pgm_model.ccr |= CC_I;   /* Mask interrupts */
  543.     pgm_model.pc = sim_read( vector_addr)  * 256;
  544.     pgm_model.pc += sim_read( vector_addr + 1 ) ;
  545.     pgm_model.pc &= 4095;
  546.     if (display_enabled)
  547.     {
  548.     settextposition( 7, 1);
  549.     delete_line(PROMPTLINE+2);
  550.     settextposition( 24, 1);
  551.     if (vector_addr == 0xFFC)
  552.        printf( "==> Interrupt service, SWI");
  553.     else if (vector_addr == 0xFFA)
  554.        printf( "==> Interrupt service, INT");
  555.     else if (vector_addr == 0xFF8)
  556.        printf( "==> Interrupt service, INT2 or TIMER");
  557.     if (pgm_model.sp > 0x7A)
  558.        printf("   *** WARNING: Stack overflow");
  559.     if (log_enabled)
  560.     {
  561.         if (vector_addr == 0xFFC)
  562.             fprintf(logfile, "==> Interrupt service, SWI");
  563.         else if (vector_addr == 0xFFA)
  564.             fprintf(logfile, "==> Interrupt service, INT");
  565.         else if (vector_addr == 0xFF8)
  566.             fprintf(logfile, "==> Interrupt service, INT2 or TIMER");
  567.         if (pgm_model.sp > 0x7A)
  568.             fprintf(logfile,"   *** WARNING: Stack overflow\n");
  569.         else
  570.         fprintf(logfile, "\n");
  571.     }
  572.     }
  573. }
  574. /**********************************************************************/
  575. int instr_or_intr()
  576. /* called from main to do one instruction */
  577. {
  578.     int i,j;
  579.  
  580.     if (!(pgm_model.ccr & CC_I))
  581.     {
  582.     if (external_intr)
  583.     {
  584.         external_intr = 0;   /* clear INT request latch */
  585.         rinterrupt( 0xFFA);   /* vector address = INT */
  586.     }
  587.     else
  588.     {
  589.         i = sim_read( TIMER_CONTROL);
  590.         j = sim_read( MISC_REGISTER);
  591.         if ( (( i & 0xC0) == 0x80) || ((j & 0xC0) == 0x80) )
  592.         rinterrupt( 0xFF8); /* vector address = timer or INT2 */
  593.     }
  594.     }
  595.     sim_instr();    /* SWI is handled as a regular instruction */
  596. }
  597.  
  598. /**********************************************************************/
  599. append_rw( readflag, addr, data)
  600. int readflag;   /* 1 = Read, 0 = Write */
  601. int addr, data;
  602. /* Used by routines in instr2.c to show bytes read, written */
  603. {
  604.     char buff[50];
  605.     if (display_enabled && !disassemble)
  606.     {
  607.     if (addr >= 0)
  608.     {
  609.         if (readflag)
  610.         sprintf( buff, "%03x=>%02x ", addr, data);
  611.         else
  612.         sprintf( buff, "%03x<=%02x ", addr, data);
  613.     }
  614.     else
  615.     {
  616.         char rname[20];
  617.  
  618.         if (addr == RW_A)
  619.         strcpy( rname, "ACCUM");
  620.         else if (addr == RW_X)
  621.         strcpy( rname, "X_REG");
  622.         else if (addr == RW_SP)
  623.         strcpy( rname, "SP");
  624.         if (readflag)
  625.         sprintf( buff, "%s=>%02x ", rname, data);
  626.         else
  627.         sprintf( buff, "%s<=%02x ", rname, data);
  628.         
  629.     }
  630.     strcat( rw, buff);
  631.     }
  632. }
  633.  
  634.  
  635.  
  636. delete_line( lineno)
  637. int lineno;
  638. {
  639. #ifdef MSC
  640.  
  641.     union REGS regs;
  642.  
  643.     lineno--;            /* DOS BIOS counts lines from 0, not 1 */
  644.     regs.h.ah = 6;       /* Service 6 = scroll text window up */
  645.     regs.h.al = 1;       /* Number of lines to scroll up */
  646.     regs.h.ch = lineno;  /* row# of up left */
  647.     regs.h.cl = 0;       /* column# of up left */
  648.     regs.h.dh = 24;      /* row# of low right */
  649.     regs.h.dl = 79;      /* column# of low right */
  650.     regs.h.bh = 7;       /* foreground white, background black, no blink */
  651.     int86( 16, ®s, ®s);
  652. #endif
  653. #ifdef VT52
  654.     settextposition( lineno, 1);
  655.     printf("\033M");    /* escape M = delete line the cursor is on */
  656.             /* the rest moves up one line, last line is free */
  657. #endif
  658. }
  659.  
  660. /************************ end of file instr.c ***************************/
  661.